import path from 'path'
import { fileURLToPath, pathToFileURL } from 'url'
import fs from 'fs'
import YAML from 'yaml'
import lodash from 'lodash'

const __filename = fileURLToPath(import.meta.url)
const __dirname = path.dirname(__filename)

/**
 * 支持锅巴插件
 * https://gitee.com/guoba-yunzai/guoba-plugin
 */
export function supportGuoba() {
  return {
    // 插件信息
    pluginInfo: {
      name: 'mys-sign-plugin',
      title: '米游社签到插件',
      author: '@Your-Name',
      authorLink: 'https://github.com/your-repo',
      link: 'https://github.com/your-repo/mys-sign-plugin',
      isV3: true,
      isV2: false,
      description: '支持原神、星穹铁道的自动签到功能，智能Cookie管理，签到推送',
      // 显示图标，可选，支持本地路径和网络路径
      // icon: 'icon.png',
      // 图标颜色，可选
      iconColor: '#d19f56',
      // 如果想要显示成插件列表，需要填写readme.md路径
      // readme: path.join(__dirname, 'README.md')
    },
    
    // 配置项
    configInfo: {
      // 配置项类型，支持 component 或 system
      type: 'component',
      // 配置项 Schema
      schemas: [
        {
          component: 'SOFT_GROUP_BEGIN',
          label: '自动签到配置',
        },
        {
          field: 'autoSign.enable',
          label: '启用自动签到',
          bottomHelpMessage: '是否启用自动签到功能',
          component: 'Switch',
        },
        {
          field: 'autoSign.gsCron',
          label: '原神签到定时表达式',
          bottomHelpMessage: '定时执行原神自动签到',
          component: 'EasyCron',
          componentProps: {
            placeholder: '请输入或选择Cron表达式',
          },
        },
        {
          field: 'autoSign.srCron',
          label: '星铁签到定时表达式',
          bottomHelpMessage: '定时执行星铁自动签到',
          component: 'EasyCron',
          componentProps: {
            placeholder: '请输入或选择Cron表达式',
          },
        },
        {
          component: 'SOFT_GROUP_BEGIN',
          label: '签到间隔配置',
        },
        {
          field: 'autoSign.interval',
          label: '账号签到间隔（秒）',
          bottomHelpMessage: '每个账号签到之间的间隔时间，避免请求过快被限制。推荐3-5秒',
          component: 'InputNumber',
          required: true,
          componentProps: {
            min: 1,
            max: 30,
            placeholder: '3',
          },
        },
        {
          field: 'autoSign.randomDelay',
          label: '随机延迟（秒）',
          bottomHelpMessage: '在间隔时间基础上增加随机延迟，使签到时间更自然。推荐0-2秒',
          component: 'InputNumber',
          required: true,
          componentProps: {
            min: 0,
            max: 10,
            placeholder: '2',
          },
        },
        {
          component: 'SOFT_GROUP_BEGIN',
          label: '推送配置',
        },
        {
          field: 'autoSign.push',
          label: '启用签到推送',
          bottomHelpMessage: '自动签到完成后是否推送结果到群聊和私聊',
          component: 'Switch',
        },
        {
          component: 'SOFT_GROUP_BEGIN',
          label: '说明',
        },
        {
          field: '_help_alert',
          component: 'Alert',
          componentProps: {
            message: '配置说明',
            description: '• 定时表达式：可视化配置或手动输入Cron表达式\n  - 每天08:00：0 0 8 * * ?\n  - 每天08:30：0 30 8 * * ?\n  - 每天20:00：0 0 20 * * ?\n• 签到间隔：建议设置3-5秒，避免请求过快\n• 随机延迟：增加0-2秒随机延迟，使签到更自然\n• 配置修改后无需重启，自动热更新生效',
            type: 'info',
          },
        },
      ],
      
      // 获取配置
      getConfigData() {
        try {
          // 优先读取用户配置
          const userConfigPath = path.join(__dirname, 'config/config.yaml')
          const defaultConfigPath = path.join(__dirname, 'config/config_default.yaml')
          
          let config = {}
          
          // 先读取默认配置
          if (fs.existsSync(defaultConfigPath)) {
            const defaultContent = fs.readFileSync(defaultConfigPath, 'utf8')
            config = YAML.parse(defaultContent) || {}
          }
          
          // 再读取用户配置，覆盖默认配置
          if (fs.existsSync(userConfigPath)) {
            const userContent = fs.readFileSync(userConfigPath, 'utf8')
            const userConfig = YAML.parse(userContent) || {}
            // 深度合并配置
            if (userConfig.autoSign) {
              config.autoSign = {
                ...config.autoSign,
                ...userConfig.autoSign
              }
            }
          }
          
          // 确保配置结构存在
          if (!config.autoSign) {
            config.autoSign = {
              enable: true,
              gsCron: '0 0 8 * * ?',
              srCron: '0 0 8 * * ?',
              interval: 3,
              randomDelay: 2,
              push: true
            }
          }
          
          logger.mark('[签到插件][锅巴] 当前配置:', JSON.stringify(config.autoSign))
          return config
        } catch (error) {
          logger.error('[签到插件][锅巴] 读取配置失败:', error)
          // 返回默认配置
          return {
            autoSign: {
              enable: true,
              gsCron: '0 0 8 * * ?',
              srCron: '0 0 8 * * ?',
              interval: 3,
              randomDelay: 2,
              push: true
            }
          }
        }
      },
      
      // 设置配置
      async setConfigData(data, { Result }) {
        const configPath = path.join(__dirname, 'config/config.yaml')
        
        try {
          logger.mark('[签到插件][锅巴] 收到保存请求')
          logger.mark('[签到插件][锅巴] 原始数据（扁平化）:', JSON.stringify(data))
          
          // 将扁平化的数据转换为嵌套对象
          // 例如 { "autoSign.enable": true } => { autoSign: { enable: true } }
          let nestedData = {}
          for (let [keyPath, value] of Object.entries(data)) {
            // 跳过虚拟字段
            if (keyPath.startsWith('_')) {
              logger.mark('[签到插件][锅巴] 跳过虚拟字段:', keyPath)
              continue
            }
            lodash.set(nestedData, keyPath, value)
          }
          
          logger.mark('[签到插件][锅巴] 转换后的数据（嵌套）:', JSON.stringify(nestedData))
          
          // 确保配置目录存在
          const configDir = path.join(__dirname, 'config')
          if (!fs.existsSync(configDir)) {
            fs.mkdirSync(configDir, { recursive: true })
            logger.mark('[签到插件][锅巴] 创建配置目录:', configDir)
          }
          
          // 读取现有配置
          let config = {}
          if (fs.existsSync(configPath)) {
            const fileContent = fs.readFileSync(configPath, 'utf8')
            config = YAML.parse(fileContent) || {}
            logger.mark('[签到插件][锅巴] 读取现有配置')
          } else {
            logger.mark('[签到插件][锅巴] 用户配置不存在，创建新配置')
          }
          
          // 使用 lodash.merge 深度合并配置
          config = lodash.merge({}, config, nestedData)
          
          logger.mark('[签到插件][锅巴] 合并后的完整配置:', JSON.stringify(config))
          
          // 写入配置文件
          const yamlContent = YAML.stringify(config)
          fs.writeFileSync(configPath, yamlContent, 'utf8')
          logger.mark('[签到插件][锅巴] 配置已写入文件:', configPath)
          
          // 验证写入
          const verifyContent = fs.readFileSync(configPath, 'utf8')
          const verifyConfig = YAML.parse(verifyContent)
          logger.mark('[签到插件][锅巴] 验证写入成功:', JSON.stringify(verifyConfig.autoSign))
          
          logger.mark('[签到插件][锅巴] ✅ 配置保存成功')
          if (config.autoSign) {
            if (config.autoSign.gsCron) {
              logger.mark(`[签到插件][锅巴] 原神签到: ${config.autoSign.gsCron}`)
            }
            if (config.autoSign.srCron) {
              logger.mark(`[签到插件][锅巴] 星铁签到: ${config.autoSign.srCron}`)
            }
            if (config.autoSign.interval !== undefined) {
              logger.mark(`[签到插件][锅巴] 签到间隔: ${config.autoSign.interval}秒 + 随机${config.autoSign.randomDelay || 0}秒`)
            }
          }
          
          // 热更新定时任务
          try {
            // 动态导入SignIn类
            const signInPath = path.join(__dirname, 'apps', 'SignIn.js')
            const signInUrl = pathToFileURL(signInPath).href
            const signInModule = await import(signInUrl)
            const { SignIn } = signInModule
            if (SignIn && SignIn.reloadTasks) {
              SignIn.reloadTasks()
              logger.mark('[签到插件][锅巴] 热更新定时任务成功')
            }
          } catch (error) {
            logger.warn('[签到插件][锅巴] 热更新定时任务失败，重启后生效:', error.message)
            logger.warn('[签到插件][锅巴] 错误详情:', error.stack)
          }
          
          return Result.ok({}, '保存成功，配置已生效')
        } catch (error) {
          logger.error('[签到插件][锅巴] 保存配置失败:', error)
          logger.error('[签到插件][锅巴] 错误堆栈:', error.stack)
          return Result.error(error.message || error)
        }
      },
    },
  }
}

